/*
 * @Author: Aaron
 * @Date: 2021-12-31 12:08:07
 * @LastEditors: Aaron Huang
 * @LastEditTime: 2022-11-19 00:31:53
 * @Description: file content
 * @FilePath: \ias_ui\src\utils\processingData.js
 * @Company: 沃尔玛
 */

import { goodsTypeList } from '@/views/coi/commonJs/dictionary.js'

/**
 * 字符串根据传入的规则切割成数组
 * @str {*} 需要切割的字符串
 * @rule {*} rule 传递切割的规则（正则或者字符串）
 * @toNumber 切换后的元素是否转换成数字
 * @returns 切割后返回的数组
 */
export function stringToArray(str, rule = '', toNumber = false) {
  if (!str || typeof str !== 'string') return []
  const result = str
    .split(rule)
    .filter((item) => item)
    .map((_) => _.trim())
  if (toNumber) return result.map((_) => Number(_))
  return result
}

/**
 * 数组转换成字符串
 * @param {*} arr 数组
 * @param {*} divide 切割符号string
 * @param {*} key Array<obj>数据类型必传。切割的字段
 * @returns 字符串
 */
export function arrayToString(arr, divide = '、', key = '') {
  try {
    if (Array.isArray(arr)) {
      if (key) {
        return arr
          .map((_) => _[key])
          .filter((_) => _)
          .join(divide)
      } else return arr.filter((_) => _).join(divide)
    } else {
      return ''
    }
  } catch (error) {
    console.log(error)
    return ''
  }
}

/**
 * 数字/字符串返回指定位置的值
 * @param {*} data 需要解析的值
 * @param {*} order 正序还是反序
 * @param {*} subscript 下标
 * @returns 指定位置的值
 */

export function subscriptValue(data, order = true, subscript = 1) {
  if (typeof data === 'number') {
    const orderSign = order ? subscript - 1 : data.toString().length - subscript
    return Number(data.toString().charAt(orderSign))
  } else if (typeof data === 'string') {
    const orderSign = order ? subscript - 1 : data.length - subscript
    if (Number(data) && data.length === Number(data).toString().length) {
      return Number(data.charAt(orderSign))
    } else {
      return data.charAt(orderSign)
    }
  } else return null
}

/**
 * 创建对象
 * [{key:对象的key，value：对象的值}]
 */
export class CreateObject {
  constructor() {
    const arr = [...arguments]
    arr.forEach((e) => {
      if (!e.key) return
      this[e.key] = e.value || null
    })
  }
}

/**
 * 根据子级类型查找所有匹配的父级类型
 * id: 子级ID
 * data: 匹配数据
 * prop: 匹配的类型,默认用ID匹配
 * children: 子节点的key名
 * complete: 返回节点的信息或者指定的prop
 */
export function getFathersById(id, data, children = 'children', prop = 'id', complete = false) {
  var arrRes = []
  const rev = (data, nodeId) => {
    for (var i = 0, length = data.length; i < length; i++) {
      const node = data[i]
      if (node[prop] === nodeId) {
        if (complete) arrRes.unshift(node)
        else arrRes.unshift(node[prop])
        return true
      } else {
        if (node[children] && node[children].length) {
          if (rev(node[children], nodeId)) {
            if (complete) arrRes.unshift(node)
            else arrRes.unshift(node[prop])
            return true
          }
        }
      }
    }
    return false
  }
  rev(data, id)
  return arrRes
}

export function geItemById(id, data, children = 'children', prop = 'id') {
  let item = {}
  const rev = (data, nodeId) => {
    for (let i = 0, length = data.length; i < length; i++) {
      const node = data[i]
      if (node[prop] === nodeId) {
        item = node
      } else {
        if (node[children] && node[children].length) {
          rev(node[children], nodeId)
        }
      }
    }
  }
  rev(data, id)
  return item
}

/**
 * 处理传给后台ID数据,只取最后一级id
 * @param {*} arr 需要处理的数据
 * @param {*} type 1单选 2多选
 */
export function handleId(arr, type) {
  if (type === 1) {
    if (arr.length) {
      return arr[arr.length - 1]
    } else return ''
  } else {
    if (arr.length) {
      const newArr = []
      arr.some((item) => {
        newArr.push(item[item.length - 1])
      })
      return newArr
    } else return []
  }
}

/**
 * 值转换成对应的码值
 * @param {*} value 需要转换的值
 * @param {*} arr 转换匹配的数组
 * @returns 转换对应的label值
 */
export function filterKey(value, arr) {
  // eslint-disable-next-line
  const newArr = arr.filter((item) => item.value == value)
  if (newArr.length) return newArr[0].label
  else return value
}
/**
 * spu适配组件数据结构
 * @param {*} arr 渠道基本属性 || 渠道类目属性
 * @param {*} isBase 是否渠道的基本属性
 * @returns 处理完的数据
 */

export function transTemplateData(arr, isBase = true, isNumber = true, isServer = false) {
  const key = isBase ? 'attrValueList' : 'attrValueIds'
  if (!Array.isArray(arr)) return arr
  arr.forEach((_) => {
    if (_.inputType === 1 || _.inputType === 2) {
      const value = _[key]
      _.attrValueList = _.valueOptions
      if (Array.isArray(value)) {
        if (_.inputType === 1) {
          if (!isServer) _.attrValue = isNumber ? value[0] && value[0].attrValueId - 0 : value[0] && value[0].attrValueId
          else {
            _.attrValue = isNumber ? value[0] && value[0].attrValueName : value[0] && value[0].attrValueName
          }
        } else _.attrValue = value.map((_) => (isNumber ? _.attrValueId - 0 : _.attrValueId))
      } else _.attrValue = value
    } else if (_.inputType === 3) {
      _.units = _.unitsOptions
    } else if (_.inputType === 10) {
      _.attrValue = typeof _.attrValue === 'string' ? _.attrValue.split('|') : []
      _.unitValue = typeof _.units === 'string' ? _.units.split('|') : []
      _.expands = _.expandsOptions
      _.units = _.unitsOptions
      _.attrValue.length = _.unitsOptions.length
      _.unitValue.length = _.unitsOptions.length
    } else if (_.inputType === 11) {
      _.attrValue = typeof _.attrValue === 'string' ? _.attrValue.split('|').map(Number) : []
      _.attrValue.length = _.inputAreaLevel - 0 + 1
    }
  })
}

/**
 * 模板的匹配数据处理成中台的数据(注意点：调用时候记得深拷贝一份数据。。不然页面异常的)
 * @param {*} arr 需要处理的数据，渠道基本或类目属性
 * @param {*} isBase 是否渠道的基本属性表
 * @returns 数组或者原来的数据，只对数字做处理，返回的结果为接口返回的数据结构类型。。
 */
export function transSavaData(arr, isBase = true) {
  const key = isBase ? 'attrValueList' : 'attrValueIds'
  // debugger
  if (!Array.isArray(arr)) return arr
  arr.forEach((_) => {
    if (_.inputType === 1 || _.inputType === 2) {
      _[key] =
        _.attrValueList &&
        _.attrValueList.filter((op) => {
          if (Array.isArray(_.attrValue)) return Boolean(typeof _.attrValue.find((value) => value === op.attrValueId) === 'number')
          else return op.attrValueId === _.attrValue || op.attrValueName === _.attrValue
        })
      _.attrValue = null
    } else if (_.inputType === 3) {
      _.units = null
    } else if (_.inputType === 10) {
      _.expands = _.expands.join('|')
      _.units = _.unitValue.join('|')
      _.attrValue = _.attrValue.join('|')
      delete _.unitValue
    } else if (_.inputType === 11) {
      _.attrValue = _.attrValue.join('|')
    }
  })
}

/**
 * spu京东沃选适配组件数据结构
 * @param {*} arr 渠道基本属性 || 渠道类目属性
 * @param {*} isBase 是否渠道的基本属性
 * @returns 处理完的数据
 */

export function transTemplateData2(arr) {
  if (!Array.isArray(arr)) return arr
  arr.forEach((_) => {
    if (_.inputType === 1 || _.inputType === 2) {
      const value = _['attrValueList']
      // _.attrValueList = _.valueOptions
      if (Array.isArray(value)) {
        if (_.inputType === 1) _.attrValue = value[0].attrValueName
        else _.attrValue = value.map((_) => _.attrValueName)
      } else _.attrValue = value
    } else if (_.inputType === 3) {
      _.units = _.unitsOptions
    } else if (_.inputType === 10) {
      _.attrValue = typeof _.attrValue === 'string' ? _.attrValue.split('|') : []
      _.unitValue = typeof _.units === 'string' ? _.units.split('|') : []
      _.expandsOptions = _.expands = _.expands.split('|')
      _.unitsOptions = _.units = [_.unitValue, _.unitValue, _.unitValue]
      _.attrValue.length = _.unitsOptions.length
      _.unitValue.length = _.unitsOptions.length
    } else if (_.inputType === 11) {
      _.attrValue = typeof _.attrValue === 'string' ? _.attrValue.split('|').map(Number) : []
      _.attrValue.length = _.inputAreaLevel - 0 + 1
    }
  })
}
/**
 * 模板的匹配数据处理成中台的数据(注意点：调用时候记得深拷贝一份数据。。不然页面异常的)
 * @param {*} arr 需要处理的数据，渠道基本或类目属性
 * @param {*} isBase 是否渠道的基本属性表
 * @returns 数组或者原来的数据，只对数字做处理，返回的结果为接口返回的数据结构类型。。
 */
export function transSavaData2(arr, isBase = true, isNumber = true) {
  const key = isBase ? 'attrValueList' : 'attrValueIds'
  if (!Array.isArray(arr)) return arr
  arr.forEach((_) => {
    if (_.inputType === 1 || _.inputType === 2) {
      if (Array.isArray(_.attrValueList)) {
        _[key] = _.attrValueList.filter((op) => {
          if (Array.isArray(_.attrValue)) return Boolean(typeof _.attrValue.find((value) => value === op.attrValueId) === (isNumber ? 'number' : 'string'))
          else return op.attrValueId === _.attrValue
        })
      }
      _.attrValue = null
    } else if (_.inputType === 10) {
      _.expands = _.expands.join('|')
      _.units = _.unitValue.join('|')
      _.attrValue = _.attrValue.join('|')
      delete _.unitValue
    } else if (_.inputType === 11) {
      _.attrValue = _.attrValue.join('|')
    } else if (_.inputType === 3) {
      if (Array.isArray(_.units)) {
        let str = ''
        _.units.forEach((item, index) => {
          if (_.units.length === index + 1) {
            str = str + item.toString()
          } else {
            str = str + item.toString() + '|'
          }
        })
        _.units = str
      }
    }
  })
}

/**
 * 特定的方法检测url是否已经携带参数
 * @param {String} url url
 * @returns 拼接时候该用？还是 &
 */

export const getPrefix = (url) => {
  const index = url.indexOf('?')
  return index === -1 ? '?' : '&'
}

/**
 * 在一段字符串中检测一段字符串片段，把这段之前或者之后的替换成自己想要的字符串（匹配的那段字符串也会给替换掉的）
 * @param {String} string 需要检测替换的字符串
 * @param {String} fragment 检测的字符串片段
 * @param {String} newString 需要替换上的字符串
 * @param {String} isTrans 是否开启转换
 * @param {Boolean} isPrefix 是否在前面（true）替换或者后面(false)
 * @return {String} 字符串
 */

export const replaceString = (string, fragment, newString, isTrans = window.open_trans_realmName, isPrefix = true) => {
  if (!isTrans) return string
  const index = string.indexOf(fragment)
  if (index === -1) return string
  else if (isPrefix) {
    const s = string.slice(index + fragment.length)
    return newString + s
  } else {
    const s = string(0, index)
    return s + newString
  }
}

/**
 * 数据加认证的token
 * @param {*} data 需要加认证的图片资源数据（string，array<string>,array<obj>,obj）
 * @param {*} key obj的key值
 * @returns 添加token的数据
 */

export function authentication(data, key, isReturn = false) {
  const copyData = JSON.parse(JSON.stringify(data))
  const clientId = window.imgAuthentication.clientId
  const token = window.imgAuthentication.token
  const tokenString = `clientId=${clientId}&accessToken=${token}`
  if (!copyData) return isReturn ? tokenString : copyData
  else if (typeof copyData === 'string') return replaceString(copyData, 'walmartmobile.cn', window.objectStorageRealmName) + getPrefix(copyData) + tokenString
  else if (Array.isArray(copyData)) {
    return copyData.map((_) => {
      if (typeof _ === 'string') return replaceString(_, 'walmartmobile.cn', window.objectStorageRealmName) + getPrefix(_) + tokenString
      else if (copyData instanceof Object && _[key]) {
        _[key] = replaceString(_[key], 'walmartmobile.cn', window.objectStorageRealmName) + getPrefix(_[key]) + tokenString
        return _
      } else return _
    })
  } else if (copyData instanceof Object && copyData[key]) {
    copyData[key] = replaceString(copyData[key], 'walmartmobile.cn', window.objectStorageRealmName) + getPrefix(copyData[key]) + tokenString
  }
  return copyData
}

/**
 *
 * @param {*} suffix src后缀
 * @param {*} rep 去除后缀
 * @param {*} questionContent html字符串
 * @returns
 */
export function replaceImgSrc(questionContent, rep = true, suffix = authentication(false, false, true)) {
  if (typeof questionContent === 'string') {
    questionContent = questionContent.replace(new RegExp(/<img [^>]*src=['"]([^'"]+)[^>]*>/gi), function (match, capture) {
      if (rep) {
        match = match.replace(new RegExp(capture, 'g'), `${capture}${suffix}`)
      } else {
        match = match.split(capture).join(capture.split('amp;').join('').split(suffix).join(''))
      }
      return match
    })
  }
  return questionContent
}

export function filterSkuInfo(sku) {
  if (sku.goodsType) sku.goodsTypeName = filterKey(sku.goodsType, goodsTypeList)
  if (sku.returnDescType === null) sku.returnDescTypeName = '文案空'
  if (sku.returnDescType || sku.returnDescType === 0) {
    const returnDescTypes = {
      0: '文案空',
      1: '支持7天无理由退货',
      2: '支持7天无理由退货（拆封后不支持）',
      3: '支持7天无理由退货（激活后不支持）',
      4: '支持7天无理由退货（使用后不支持）',
      5: '支持7天无理由退货（安装后不支持）',
      12: '支持15天无理由退货',
      13: '支持15天无理由退货（拆封后不支持）',
      14: '支持15天无理由退货（激活后不支持）',
      15: '支持15天无理由退货（使用后不支持）',
      16: '支持15天无理由退货（安装后不支持）',
      22: '支持30天无理由退货',
      23: '支持30天无理由退货（安装后不支持）',
      24: '支持30天无理由退货（拆封后不支持）',
      25: '支持30天无理由退货（使用后不支持）',
      26: '支持30天无理由退货（激活后不支持）'
    }
    sku.returnDescTypeName = returnDescTypes[sku.returnDescType]
  }
  if ('returnType' in sku) {
    if (sku.returnType === null) sku.returnTypeName = '支持7天无理由退货'
    if ([0, 3].indexOf(sku.returnType) !== -1) sku.returnTypeName = '不支持7天无理由退货'
    if ([1, 5, 8].indexOf(sku.returnType) !== -1) sku.returnTypeName = '支持7天无理由退货'
    if ([2].indexOf(sku.returnType) !== -1) sku.returnTypeName = '支持90天无理由退货'
    if ([4, 7].indexOf(sku.returnType) !== -1) sku.returnTypeName = '支持15天无理由退货'
    if ([6].indexOf(sku.returnType) !== -1) sku.returnTypeName = '支持30天无理由退货'
  }
  if ('saleStatus' in sku) {
    if (sku.returnType === 1) sku.saleStatusName = '可售'
    if (sku.returnType === 0) sku.saleStatusName = '不可售'
  }
  return sku
}

// 判断是不是json

export const IsJsonString = (str) => {
  try {
    JSON.parse(str)
  } catch (e) {
    return false
  }
  return true
}
